<!DOCTYPE HTML>
<html>
<head>
<title>脚本语言 | AutoHotkey</title>
<meta name="description" content="Learn details about the language such as comments, expressions, legacy syntax, commands, control flow statements, structure of a script, etc." />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<link href="static/theme.css" rel="stylesheet" type="text/css" />
<script src="static/content.js" type="text/javascript"></script>
<script type="text/javascript">$(function(){0<=window.navigator.userAgent.toLowerCase().indexOf("ucbrowser")&&CaoNiMaDeUc()})</script>
</head>
<body>
<h1>脚本语言</h1>
<p>一个 AutoHotkey 脚本从根本上说是使用 AutoHotkey 独有的自定义语言编写的程序要遵循的指令集合. 这种语言与其他几种脚本语言有一些相似之处, 但也有其独特的优势和缺陷. 本文档描述了该语言, 并试图指出常见的缺陷.</p>
<p class="note">有关 AutoHotkey 所使用的各种概念的更一般的解释, 请参阅<a href="Concepts.htm">概念和约定</a>.</p>
<p class="warning">在 AutoHotkey 中使用两种不同的语法样式: <a href="#legacy-syntax">传统语法</a>和<a href="#expressions">表达式</a>.</p>

<h2 id="toc">目录</h2>
<ul>
  <li><a href="#general-conventions">常规约定</a></li>
  <li><a href="#comments">注释</a></li>
  <li><a href="#expressions">表达式</a>
  <ul>
    <li><a href="#strings">字符串 / 文本</a></li>
    <li><a href="#variables">变量</a></li>
    <li><a href="#operators">运算符</a></li>
    <li><a href="#function-calls">函数调用</a></li>
    <li><a href="#operators-for-objects">对象的运算符</a></li>
    <li><a href="#expression-statements">表达式语句</a></li>
  </ul></li>
  <li><a href="#legacy-syntax">传统语法</a></li>
  <li><a href="#commands">命令</a>
  <ul>
    <li><a href="#outputvar-and-inputvar-parameters">OutputVar 和 InputVar 参数</a></li>
    <li><a href="#text-parameters">文本参数</a></li>
    <li><a href="#numeric-parameters">数字参数</a></li>
    <li><a href="#-expression">% 表达式</a></li>
    <li><a href="#documentation-conventions">文档约定</a></li>
    <li><a href="#optional-parameters">可选参数</a></li>
  </ul></li>
  <li><a href="#expressions-vs-legacy-syntax">表达式与传统语法</a>
  <ul>
    <li><a href="#different-equals">不同的等号</a></li>
    <li><a href="#commands-vs-functions">命令与函数</a></li>
  </ul></li>
  <li><a href="#control-flow">控制流语句</a>
  <ul>
    <li><a href="#control-flow-vs-commands">控制流与命令</a></li>
    <li><a href="#if-statement">If 语句</a></li>
    <li><a href="#loop-statement">Loop 语句</a></li>
    <li><a href="#not-control-flow">非控制流</a></li>
  </ul></li>
  <li><a href="#structure-of-a-script">脚本的结构</a>
  <ul>
    <li><a href="#auto-execute-section">自动执行段</a></li>
    <li><a href="#subroutines">子程序</a></li>
    <li><a href="#user-defined-functions">用户定义的函数</a></li>
    <li><a href="#-include">#Include</a></li>
  </ul></li>
  <li><a href="#misc">杂项</a>
  <ul>
    <li><a href="#dynamic-variables">动态变量</a>
    <ul>
      <li><a href="#pseudo-arrays">伪数组</a></li>
      <li><a href="#associative-pseudo-arrays">关联伪数组</a></li>
      <li><a href="#commands-which-create-pseudo-arrays">创建伪数组的命令</a></li>
    </ul></li>
    <li><a href="#labels">标签</a></li>
  </ul></li>
</ul>
<!-- TODO:
Directives
Declarations
Class definitions
Methods?
-->

<h2 id="general-conventions">常规约定</h2>
<p><strong>名称:</strong> 变量和函数名称不区分大小写(例如, <code>CurrentDate</code> 和 <code>currentdate</code> 是一样的). 有关最大长度和可用字符等详细信息, 请参阅<a href="Concepts.htm#names">名称</a>.</p>
<p><strong>无类型变量:</strong> 变量没有明确定义的类型; 相反, 任何类型的值都可以存储在任何变量中(不包括内置变量). 数字可能会自动转换为字符串(文本), 反之亦然, 这取决于实际情况.</p>
<p><strong>声明是可选的:</strong> 除了在<a href="Functions.htm">函数页面</a>上注明的地方外, 不需要声明变量; 它们的存在仅仅是通过使用它们(每个变量都是从空/空白开始的).</p>
<p><strong>空格通常被忽略:</strong> 缩进(前导空格) 对于编写可读代码非常重要, 但是程序不需要, 通常会被忽略. <em>通常</em> 在行尾的, 表达式内的(引号之间的除外), 以及命令参数之前和之后的空格和制表符会被忽略. 然而, 在一些情况下, 空格是重要的, 包括:</p>
<ul>
  <li><a href="#function-calls">函数</a>和方法调用要求在函数/方法名称和 <code>(</code> 之间没有空格.</li>
  <li>连接时需要空格.</li>
  <li>两个运算符之间可能需要空格, 以消除歧义.</li>
  <li>单行<a href="#comments">注释</a>如果不在行首, 则需要前导空格.</li>
</ul>
<p><strong>换行符是有意义的:</strong> 换行符通常作为语句分隔符, 终止前一个命令或表达式. (<em>语句</em> 只是语言中表示要执行某些操作的最小的独立元素.) 这个例外是行延续(请参见下文).</p>
<p><strong>行延续:</strong> 长行可以分成一些小行, 以提高可读性和可维护性. 这是通过预处理实现的, 所以不属于这种语言的一部分. 有两种方法:</p>
<ul>
  <li><a href="Scripts.htm#continuation-line">行延续</a>, 以<a href="Variables.htm#operators">表达式运算符</a>(++ 和 -- 除外) 开始的行与前一行合并. 行被合并, 而不管该行是否实际包含表达式.</li>
  <li><a href="Scripts.htm#continuation-section">延续片段</a>, 其中多行与片段上方的行合并. 延续片段的开始和结束标记为 <code>(</code> 和 <code>)</code>(两个符号必须出现在行的开头, 不计空格).</li>
</ul>

<h2 id="comments">注释</h2>
<p><em>注释</em> 是脚本中被程序忽略的那部分文本. 它们通常用于添加解释或禁用部分代码.</p>
<p>可以通过在行的开头使用分号来注释脚本. 例如:</p>
<pre><em>; 这整行是注释.</em></pre>
<p>也可以在行的末尾添加注释, 此时分号左侧必须至少有一个空格或 tab. 例如:</p>
<pre>Run Notepad  <em>; 这是和命令在同一行的注释.</em></pre>
<p>此外, 可以使用 <code><em>/*</em></code> 和 <code><em>*/</em></code> 符号注释整块代码, <em>但仅当它们出现在行首时才有效</em>(空白除外), 如下例所示:</p>
<pre><em>/*
MsgBox, 这行被注释掉了(禁用).
MsgBox, 常见的错误: */ 这不会结束注释.
MsgBox, 这行被注释掉了. 
*/</em>
</pre>
<p>由于脚本运行时会忽略注释, 所以它们不会影响脚本性能或占用内存.</p>
<p>使用 <a href="commands/_CommentFlag.htm">#CommentFlag</a> 可以把默认的注释符号(分号) 改为其他字符或字符串.</p>

<h2 id="expressions">表达式</h2>
<p><em>表达式</em> 是一个或多个<a href="Concepts.htm#values">值</a>, <a href="Concepts.htm#variables">变量</a>, <a href="#operators">运算符</a>和<a href="#function-calls">函数调用</a>的组合. 例如, <code>10</code>, <code>1+1</code> 和 <code>MyVar</code> 是有效的表达式. 通常, 表达式将一个或多个值作为输入, 执行一个或多个操作, 并生成一个值作为结果. 找出表达式值的过程被称为 <em>计算</em>. 例如, 表达式 <code>1+1</code> <em>计算</em> 结果为数字 2.</p>
<p><a href="#commands">命令</a>的目的是获取参数列表, 每行只执行一个动作, 而简单的表达式可以拼凑在一起形成越来越复杂的表达式. 例如, 如果 <code>Discount/100</code> 将折扣百分比转换为分数, <code>1 - Discount/100</code> 计算剩余金额的分数, 而 <code>Price * (1 - Discount/100)</code> 应用它来产生净价格. (译者注: 英语和汉语在打折的说法上是相反的, 例如 10% off, discount prices at 10% 表示去除 10%, 汉语打九折的意思.)</p>
<p><em>值</em> 是<a href="Concepts.htm#numbers">数字</a>, <a href="Concepts.htm#objects">对象</a>或<a href="Concepts.htm#strings">字符串</a>. <em>字面</em>值是在脚本中写入的值; 当您在查看代码时可以看到该值.</p>

<h3 id="strings">字符串 / 文本</h3>
<p class="note">有关字符串的更一般的解释, 请参阅<a href="Concepts.htm#strings">字符串</a>.</p>
<p><em>字符串</em> 或 <em>字符组成的串</em>, 只是一个文本值. 在表达式中, 原义的文本必须用引号引起来, 以区分变量名称或其他表达式. 这通常被称为 <em>加引号的原义字符串</em>, 或者为 <em>加引号的字符串</em>. 例如, <code>"This is a quoted string."</code>.</p>
<p>要在原义字符串中包含 <em>真实的</em> 引号字符, 请指定两个连续的引号, 如下面例子中的演示: <code>"她说, ""一个苹果一天."""</code>.</p>
<p>加引号的字符串能包含<a href="misc/EscapeChar.htm">转义序列</a>例如 <code>`t</code>(tab 制表符), <code>`n</code>(换行) 和 <code>`r</code>(回车). 与<a href="#unquoted-text">不加引号的字符串</a>不同的是, 不需要转义逗号或百分号, 因为加引号的字符串不能包含变量. 现在不支持使用 <code>`"</code> 转义序列来产生原义的引号字符; 而是使用两个连续的引号, 如上所示.</p>

<h3 id="variables">变量</h3>
<p class="note">有关变量的基本解释和一般细节, 请参阅<a href="Concepts.htm#variables">变量</a>.</p>
<p><em>变量</em> 可以简单地通过写变量名来用于表达式. 例如, <code>A_ScreenWidth/2</code>. 但是, 变量不能在加引号的字符串中使用. 作为替代, 变量和其他值可以通过名为<a href="Variables.htm#concat"><em>连接</em></a>的过程与文本组合起来. 有两种方法能用于 <em>连接</em> 表达式中的值:</p>
<ul>
  <li>隐式连接: <code>"The value is " MyVar</code></li>
  <li>显式连接: <code>"The value is " . MyVar</code></li>
</ul>
<p>隐式连接也被称为 <em>自动连接</em>. 在这两种情况下, 变量和点之前的空格都是必需的.</p>
<p><a href="commands/Format.htm">Format</a> 函数也可以用于此目的. 例如:</p>
<pre>MsgBox % Format("You are using AutoHotkey v{1} {2}-bit.", A_AhkVersion, A_PtrSize*8)
</pre>
<p>要为变量赋值, 请使用 <code>:=</code> <a href="Variables.htm#AssignOp">赋值运算符</a>, 如 <code>MyVar := "Some text"</code>.</p>
<p>表达式中的 <em>百分号</em> 用于创建<a href="#dynamic-variables">动态变量引用</a>和<a href="Functions.htm#DynCall">动态函数调用</a>. 大多数情况下, 这些结构是不需要的, 所以一般来说, 变量名不应该包含在表达式的百分号中.</p>

<h3 id="operators">运算符</h3>
<p><em>运算符</em> 用符号或符号组的形式, 如 <code>+</code> 或 <code>:=</code>, 或者其中一个单词 <code>and</code>, <code>or</code>, <code>not</code> 或 <code>new</code>. 他们将一个, 两个或三个值作为输入, 并返回一个值作为结果. 用作运算输入的值或子表达式称为 <em>运算元</em>.</p>
<ul>
  <li><em>一元</em> 运算符可以写在单个运算元之前或之后, 这具体取决于运算符. 例如, <code>-x</code> 或 <code>not keyIsDown</code>.</li>
  <li><em>二元</em> 运算符写在两个运算元之间. 例如, <code>1+1</code> 或 <code>2 * 5</code>.</li>
  <li>AutoHotkey 只有一个 <em>三元</em> 运算符, 它采用如下的形式 <a href="Variables.htm#ternary"><code>condition(条件) ? valueIfTrue(条件为真时的值) : valueIfFalse(条件为假时的值)</code></a>.</li>
</ul>
<p>一些一元和二元运算符共享相同的符号, 在这种情况下,  运算符的含义取决于它是写在两个值之前, 之后还是之间. 例如, <code>x-y</code> 执行减法, 而 <code>-x</code> 反转 <code>x</code> 的符号(从负值产生正值, 反之亦然).</p>
<p>除非在<a href="Variables.htm#operators">运算符表</a>中另有规定, 否则相同优先级的运算符(例如乘(<code>*</code>) 和除(<code>/</code>)) 将按从左到右的顺序进行计算. 相反, 诸如加(<code>+</code>) 之类的较低优先级的运算符在诸如乘(<code>*</code>) 之类的较高运算符之后被计算. 例如, <code>3 + 2 * 2</code> 作为 <code>3 + (2 * 2)</code> 计算. 括号可以用来覆盖优先级, 如以下示例所示: <code>(3 + 2) * 2</code></p>

<h3 id="function-calls">函数调用</h3>
<p class="note">有关函数和相关术语的一般解释, 请参阅<a href="Concepts.htm#functions">函数/命令</a>.</p>
<p><em>函数</em> 需要可变化数量的输入, 去执行一些动作或计算, 然后<a href="Concepts.htm#return-a-value"><em>返回</em></a>一个结果. 函数的输入被称为<a href="Concepts.htm#parameters">参数</a>(<em>parameters</em> 或 <em>arguments</em>). 一个函数被简单地通过写它的名字, 后跟着用括号括起来的参数来<a href="Concepts.htm#call"><em>调用</em></a>. 例如, 如果 <kbd>Shift</kbd> 被按下, 则 <code>GetKeyState("Shift")</code> 返回(计算出) 1, 否则返回 0.</p>
<p class="warning"><strong>注意:</strong> 函数名和左括号之间不能有空格.
</p>
<p>与<a href="#commands">命令</a>相比, 括号的要求起初可能看起来含糊不清或冗长, 但是它们允许将函数调用与其他操作结合起来. 例如, 只有当两个键被物理按下时, 表达式 <code>GetKeyState("Shift", "P") and GetKeyState("Ctrl", "P")</code> 才会返回 1.</p>
<p>函数名称始终是全局的, 并且与变量名称是分开的. 例如, <code>Round</code> 可以同时是一个变量名和一个函数名, 然而 <code>Round := 1</code> 不会以任何方式影响 <code>Round(n)</code>.</p>

<h3 id="operators-for-objects">对象的运算符</h3>
<p>这里表达式中使用的其他符号不完全符合上面定义的任何类别, 或影响表达式其他部分的含义, 如下所述. 这些都以某种方式与 <em>对象</em> 有关. 对于每个构造所做的事情提供一个完整的解释, 需要引入更多的概念, 而这不属于本节的范围.</p>
<p><code>Alpha.Beta</code> 通常称为 <em>成员访问</em>. <em>Alpha</em> 是一个普通变量, 可以用函数调用或其他一些返回对象的子表达式替换. 当计算时, 对象发送一个请求 "给我属性 <em>Beta</em> 的值", "在属性 <em>Beta</em> 中存储这个值" 或 "调用名为 <em>Beta</em> 的方法". 换句话说, <em>Beta</em> 是一个对对象有意义的名字; 它不是一个局部或全局变量.</p>
<p><code>Alpha.Beta()</code> 是一个 <em>方法调用</em>, 如上所述.</p>
<p><code>Alpha.Beta[Param]</code> 是成员访问的一种特殊形式, 其中包括了请求中的附加参数. <em>Beta</em> 只是一个简单的名称, 但 <em>Param</em> 是一个普通的变量或子表达式, 或者是由逗号分隔的子表达式列表(与函数的参数列表中相同).</p>
<p><code>Alpha[Index]</code> 具有与 <code>Alpha.Beta</code> 类似的功能, 但每个部分都以更加标准的方式进行解释. 也就是说, 在这种情况下, <em>Alpha</em> 和 <em>Index</em> 都是变量, 实际上可以用任何子表达式替换. 此语法通常用于检索<a href="Objects.htm#Usage_Simple_Arrays">数组</a>或<a href="Objects.htm#Usage_Associative_Arrays">关联数组</a>中的元素.</p>
<p><code>new ClassName()</code> 用于实例化一个类, 或者创建一个从另一个对象派生的对象. 虽然这看起来像一个函数调用, 但 <em>ClassName</em> 实际上是一个普通的变量. 同样, <code>new Alpha.Beta()</code>将创建一个从 <code>Alpha.Beta</code> 返回的对象派生的对象; <em>Beta</em> 既不是函数也不是方法. 如果存在可选的括号, 则可能包含对象的 <a href="Objects.htm#Custom_NewDelete">__New</a> 方法的参数.</p>
<p><code>[A, B, C]</code> 创建一个初始内容为 A, B 和 C(本例中的所有变量) 的<a href="Objects.htm#Usage_Simple_Arrays">数组</a>, 其中 A 是元素 1.</p>
<p><code>{Key1: Value1, Key2: Value2}</code> 从键值对列表中创建一个<a href="Objects.htm#Usage_Associative_Arrays">关联数组</a>. 以后值可以通过其关联的键来检索. 在 <code>:</code> 左侧写入一个简单的单词(由字母数字字符, 下划线和非 ASCII 字符组成) 等同于将该单词括在引号中. 例如, <code>{A: B}</code> 等同于 <code>{"A": B}</code>. 但是, <code>{(A): B}</code> 使用变量 <code>A</code> 的内容作为键.</p>
<p><code>MyFunc(Params*)</code> 是一个<a href="Functions.htm#VariadicCall">可变函数调用</a>. 星号必须紧跟在函数参数列表末尾的右括号之前. <em>参数</em> 必须是返回数组对象的变量或子表达式. 尽管在任何地方使用 <code>Params*</code> 都是无效的, 但它可以用在数组文字(<code>[A, B, C, ArrayToAppend*]</code>) 或索引器(<code>Alpha[Params*]</code>) 中.</p>

<h3 id="expression-statements">表达式语句</h3>
<p>并不是所有的表达式都可以单独在一行上使用. 例如, 只包含 <code>21*2</code> 或 <code>"Some text"</code> 的行就没有任何意义. 表达式 <em>语句</em> 是一个单独使用的表达式, 通常利用它的附加作用. 大多数带有附加作用的表达式都可以这样使用, 所以一般不需要记住本节的细节.</p>
<p>以下类型的表达式可以用作语句:</p>
<p>赋值, 如 <code>x := y</code>, 复合赋值, 如 <code>x += y</code> 和增量/减量运算符, 如 <code>++x</code> 和 <code>x--</code>. 但是, 在 AutoHotkey v1 中, <code>++</code>, <code>--</code>, <code>+=</code>, <code>-=</code>, <code>*=</code> 和 <code>/=</code> 在单独使用时会有稍微不同的行为, 因为它们实际上等同于 EnvAdd, EnvSub, EnvMult 或 EnvDiv. 有关详细信息, 请参阅运算符列表中的<a href="Variables.htm#AssignOp">赋值</a>下的 "已知限制".</p>
<p>函数调用, 如 <code>MyFunc(Params)</code>. 但是, 一个独立的函数调用不能跟随一个大括号 <code>{</code>(在行尾或下一行), 因为它会与函数声明混淆.</p>
<p>方法调用, 如 <code>MyObj.MyMethod()</code>.</p>
<p>使用方括号的成员访问, 如 <code>MyObj[Index]</code>, 它可能有类似于函数调用的附加作用.</p>
<p>表达式以 <code>new</code> 运算符开始, 如在 <code>new ClassName</code> 中, 因为有时一个类可以被实例化, 只是为了它的附加作用.</p>
<p>三元表达式如 <code>x ? CallIfTrue() : CallIfFalse()</code>. 但是, 在 AutoHotkey v1 中, 命令名称优先. 例如, <code>MsgBox ? 1 : 0</code> 显示一个消息框.</p>
<p class="warning"><strong>注意:</strong> 在 AutoHotkey v1 中, 命令名称优先于三元运算. 例如, <code>MsgBox ? 1 : 0</code> 显示一个消息框.</p>
<p class="warning"><strong>注意:</strong> 条件不能以 <code>!</code> 或任何其他表达式操作符开始, 因为它将被解释为<a href="Scripts.htm#continuation-line">连续行</a>.</p>
<p>表达式以 <code>(</code> 开始. 但是, 通常必须在同一行有一个匹配 <code>)</code>, 否则该行将被解释为<a href="Scripts.htm#continuation">延续片段</a>的开始.</p>
<p>为了简单起见, 我们还可以从上面描述的任一表达式(但不是下面描述的) 开始. 例如, <code>MyFunc()+1</code> 目前是允许的, 尽管 <code>+1</code> 没有效果, 其结果会被丢弃. 由于错误检查的增强, 这些表达式在将来可能会失效.</p>
<p>成员访问使用点(一次或一系列), 如 <code>ExcelApp.Quit</code> 或 <code>x.y.z</code>. 但是, 除非使用圆括号(在方法调用中), 否则这不能是更大表达式的前缀. 例如, <code>ExcelApp.Quit, xxx</code> 是被禁止的, 由于与命令语法明显相似.</p>

<h2 id="legacy-syntax">传统语法</h2>
<p><em>传统语法</em> 或 <em>命令</em> 语法通常只允许每行执行一个操作, 但是使用更少的字符来执行简单的任务, 例如, <a href="commands/Send.htm">发送按键</a>或<a href="commands/Run.htm">运行一个程序</a>. 该语法由命令和变量名称, <em>不加引号的文本</em> 和一些符号, 如 <code>,</code>, <code>=</code> 和 <code>%</code> 组成.</p>
<p id="unquoted-text"><em>不加引号的文本</em> 只是文本, 不用括在双引号中, 直接使用. 由于文本没有明确的开始和结束标记, 所以在行尾或参数结束时结束. 前导和尾随空格和制表符被忽略. 在不加引号的文本中, 以下字符具有特殊含义:</p>
<ul>
  <li>
<p><code>%</code>: 用百分号括起一个变量名以包含该变量的内容. 例如, <code>The year is %A_Year%.</code></p>
<p class="warning"><strong>注意:</strong> 变量名并非 <em>总是</em> 用百分号括起来; 百分号只在变量名和不加引号的文字一起时才需要. 除了创建<a href="#dynamic-variables">动态变量引用</a>或<a href="Functions.htm#DynCall">动态函数调用</a>之外, 不应在其他任何地方使用百分号.
</p>
<p class="warning"><strong>注意:</strong> 只能使用普通变量名. 不支持<a href="Objects.htm#Usage_Simple_Arrays">数组元素</a>, <a href="Objects.htm#Usage_Objects">属性</a>和其他<a href="#expressions">表达式</a>.
</p>
</li>
  <li>
<p><code>,</code>: 逗号用于分隔命令的参数, 但有<a href="#escape-comma">一些例外</a>. 在赋值或比较中使用时, 它没有特殊的含义, 因此在这种情况下被原义解释.</p>
</li>
  <li>
<p><code>`</code>: <a href="misc/EscapeChar.htm">转义符</a>通常用于指示紧跟其后的字符应与通常的解释不同. 例如, <code>`%</code> 生成一个原义百分号 而 <code>`,</code> 生成一个原义逗号. 其他一些常见的转义序列产生特殊字符, 如 <code>`t</code>(制表符 tab), <code>`n</code>(换行) 和 <code>`r</code>(回车).</p>
</li>
</ul>
<p><a href="#commands">命令</a>接收<a href="#text-parameters">不加引号的文本</a>, <a href="#outputvar-and-inputvar-parameters">变量名</a>和<a href="#numeric-parameters">数字表达式</a>的混合使用.</p>
<pre>Send, The time is %A_Hour% o'clock.
</pre>
<p><a href="commands/SetEnv.htm">传统赋值</a>将<a href="#unquoted-text">不加引号的文本</a>赋值到变量.</p>
<pre>Clipboard = This text is copied to the clipboard.
</pre>
<p><a href="#if-statement">If 语句</a>仅在满足指定的条件时才执行操作.</p>
<pre>If Var = Text value
</pre>
<p>还有其他一些<a href="#control-flow">控制流语句</a>(如 loop), 它们使用与命令相似的传统语法.</p>

<h2 id="commands">命令</h2>
<p><em>命令</em> 是执行特定预定义操作的指令. "命令" 也可以指一个特定的预定义的操作, 如 <a href="commands/MsgBox.htm">MsgBox</a>. 可用<a href="commands/index.htm">命令</a>集是预定义的, 不能被脚本改变.</p>
<p>一个命令简单地通过在一行的开始处写入它的名称来 <em>调用</em>, 后面可以跟着参数. 例如:</p>
<pre>MsgBox, The time is %A_Hour% o'clock.
</pre>
<p>将命令名与参数分开的逗号是可选的, 但以下情况除外:</p>
<ul>
  <li>
<p>当需要防止该行被解释为<a href="commands/SetEnv.htm">传统赋值</a>或<a href="Variables.htm#AssignOp">赋值表达式</a>时.</p>
<pre>MsgBox, := This would be an assignment without the comma.
</pre>
</li>
  <li>
<p>当第一个参数是空的.</p>
<pre>MsgBox,, Second, Third
</pre>
</li>
  <li>
<p>单独的命令在<a href="Scripts.htm#continuation">延续片段</a>的顶部.</p>
</li>
</ul>
<p>命令的每个参数都可以接受不同的语法, 具体取决于命令. 有四种类型的参数:</p>
<ul>
  <li>OutputVar(输出变量)</li>
  <li>InputVar(输入变量)</li>
  <li>Text(文本)</li>
  <li>Number(数字)</li>
</ul>
<p>在大多数情况下, <a href="#-expression">百分号前缀</a>可以用来传递一个表达式.</p>

<h3 id="outputvar-and-inputvar-parameters">OutputVar 和 InputVar 参数</h3>
<p><em>OutputVar</em> 和 <em>InputVar</em> 参数需要一个变量名或<a href="#dynamic-variables">动态变量引用</a>. 例如:</p>
<pre><em>; 用加号替换所有空格:</em>
StringReplace, NewStr, OldStr, %A_Space%, +, All
</pre>
<p>该命令从 <em>OldStr</em>(InputVar) 中读取值并将结果存储在 <em>NewStr</em>(OutputVar) 中.</p>
<p class="warning"><strong>注意:</strong> 只有一个普通变量可以用作 <em>OutputVar</em>. <a href="Objects.htm#Usage_Simple_Arrays">数组元素</a>, <a href="Objects.htm#Usage_Objects">属性</a>和其他的<a href="#expressions">表达式</a>不受支持.
</p>
<p>只有当<a href="#-expression">百分号前缀</a>使用时, <em>InputVar</em> 参数才能接受一个表达式. 但是, 百分号前缀在<a href="#legacy-if">传统 If 命令</a>的 <em>Var</em> 参数中不受支持, 所以应该使用 <a href="commands/IfExpression.htm">If (表达式)</a> .</p>

<h3 id="text-parameters">文本参数</h3>
<p>文本参数接受<a href="#unquoted-text">不加引号的文本</a>. 例如:</p>
<pre>MsgBox, The time is %A_Hour% o'clock.
</pre>
<p id="escape-comma">因为逗号和百分号具有特殊的意义, 使用<a href="commands/_EscapeChar.htm">转义序列</a> <code>`,</code> 去指定原义逗号 <code>`%</code> 去指定原义百分号. 为了清楚起见, 最好总是转义任何旨在为原义的逗号, 但在以下情况下转义逗号是可选的:</p>
<ul>
  <li>在任何命令的最后一个参数.</li>
  <li>MsgBox 的 <em>Text</em> 参数, 它有智能逗号处理.</li>
</ul>
<p>要包含前导或尾随空格或制表符, 请使用内置变量 <a href="Variables.htm#Space">%A_Space%</a> 和 <a href="Variables.htm#Tab">%A_Tab%</a> 或强制表达式如 <code>% " x "</code>. <span class="ver">[v1.1.06+]</span>: 空格也可以通过在空格或制表符之前加上一个<a href="misc/EscapeChar.htm">转义序列</a>来保留, 除了行末的空格之外.</p>
<p>文本参数也接受<a href="#-expression">强制表达式</a>.</p>

<h3 id="numeric-parameters">数字参数</h3>
<p>数字参数接受原义数字或<a href="#expressions">表达式</a>, 并可以通过类似 "此参数可以是表达式." 的措辞进行标识.</p>
<p>由于历史原因, 只是单独的变量引用或与数字结合不被解释为表达式. 例如:</p>
<pre>Sleep %n%000  <em>; 等待 n 秒.</em>
Sleep %m%     <em>; 等待 m 毫秒.</em>
</pre>
<p>要在这种情况下执行<a href="#dynamic-variables">双重解引</a>, 请将表达式括在括号内: <code>Sleep (%m%)</code></p>
<p>请注意, 混合类型参数, 如 <a href="commands/SetTimer.htm">SetTimer</a> 的第二个参数, 有时接受一个数字有时接受如 <code>On</code> 或 <code>Off</code> 的字符串, 实际上是文本参数, 除非使用<a href="#-expression">百分号前缀</a>, 否则它们不接受表达式.</p>
<p>数字参数允许但忽略<a href="#-expression">百分号前缀</a>.</p>

<h3 id="-expression">% 表达式</h3>
<p>尽管纯粹的数字参数在默认情况下接受一个表达式, 但所有其他的命令参数都不会. 指定一个百分号后跟一个空格或制表符来强制一个参数接受一个<a href="#expressions">表达式</a>. 例如, 以下所有内容都是完全相同的, 因为 <a href="commands/Sleep.htm">Sleep</a> 的第一个参数是接受表达式的:</p>
<pre>Sleep MillisecondsToWait
Sleep %MillisecondsToWait%
Sleep % MillisecondsToWait
</pre>
<p class="warning"><strong>注意:</strong> 在<a href="#numeric-parameters">数字参数</a>中使用百分号空格前缀不一定会强制它成为表达式.</p>
<p>除以下各项外, 所有参数都支持百分号空格前缀:</p>
<ul>
  <li>任何<a href="#legacy-if">传统的 If</a> 命令的 <em>Var</em> 参数. 用户可以通过总是使用 <a href="commands/IfExpression.htm">if (表达式)</a> 来避免混淆.</li>
  <li><em>OutputVar</em> 参数, 它使用与表达式相同的语法接受变量引用.</li>
</ul>
<p>一些用户可能会发现, 总是强制执行一个表达式更容易使用, 并尽可能保持一致的语法(表达式语法).</p>

<h3 id="documentation-conventions">文档约定</h3>
<p>在每个命令文档的顶部, 通常有一个显示语法的块, 如下所示:</p>
<pre class="Syntax"><span class="func">StringLower</span>, OutputVar, InputVar <span class="optional">, T</span></pre>
<p>方括号表示可选参数; 方括号本身必须在实际代码中省略.</p>
<p>有时, 参数所接受的值直接写入语法块中. 例如, 上面显示的 StringLower 的第三个参数接受字母 T 作为文本. 参数的确切语法在 <em>参数</em> 部分中进行了描述, 并在命令之间有所不同.</p>

<h3 id="optional-parameters">可选参数</h3>
<p>可选参数可以简单地留空. 如果省略所有后续参数, 则可选参数前面的逗号也可以省略. 例如, <a href="commands/Run.htm">Run</a> 命令能接受一到四个参数. 以下全部有效:</p>
<pre>Run, notepad.exe, C:\
Run, notepad.exe,, Min
Run notepad.exe, , , notepadPID
</pre>

<h2 id="expressions-vs-legacy-syntax">表达式与传统语法</h2>
<p>许多命令参数默认情况下不接受表达式. 在参数的开始处使用<a href="#-expression">百分号-空格前缀</a>为表达式来计算该参数. 在以下示例中, 表达式显示在第一行(在百分号 <em>之后</em> 开始), 第二行显示纯传统语法.</p>
<pre>MsgBox % 1+1  <em>; Shows "2"</em>
MsgBox   1+1  <em>; Shows "1+1"</em>
</pre>
<p>表达式中的原义文本总是用引号括起来. 这些被称为 <em>加引号字符串</em>.</p>
<pre>MsgBox % "This is text."
MsgBox    This is text.
</pre>
<p>表达式中的变量不包围在百分号中, 除非创建<a href="#dynamic-variables">双重引用</a>.</p>
<pre>MsgBox %  A_AhkVersion
MsgBox   %A_AhkVersion%
</pre>
<p>变量不能在加引号的字符串中使用.</p>
<pre>MsgBox % "Hello %A_UserName%."  <em>; 显示 "%A_UserName%"</em>
MsgBox    Hello %A_UserName%.   <em>; 显示你的用户名.</em>
</pre>
<p>作为代替, 通过将它们按顺序写入, 使用空格或制表符, 或被空格包围的点分隔, 将值<a href="Variables.htm#concat"><em>连接</em></a>起来.</p>
<pre>MsgBox % "Hello " . A_UserName . "."  <em>; 显示你的用户名.</em>
</pre>
<p>一种替代方法是使用 <a href="commands/Format.htm">Format</a> 函数, 它也可以以各种方式格式化参数值.</p>
<pre>MsgBox % Format("Hello {1}.", A_UserName)  <em>; {} 也可以代替 {1}.</em>
</pre>
<p>一个值被赋值给一个变量, 使用 <code>:=</code> 代替 <code>=</code>:</p>
<pre>MyVar := "This is text."
MyVar = This is text.
</pre>
<p>使用与<a href="#legacy-if">传统的 If</a> 命令相同的符号执行比较: <code>=</code>, <code>&lt;&gt;</code> 或 <code>!=</code>, <code>&gt;</code>, <code>&gt;=</code>, <code>&lt;</code> 和 <code>&lt;=</code>.</p>
<pre>if (Var1 = Var2)
if Var1 = %Var2%
</pre>
<p>在表达式中, 这两个值可以是简单的值或复杂的子表达式. 比较也可以使用, 如 <code>and</code> 和 <code>or</code> (这等同于 <code>&amp;&amp;</code> 和 <code>||</code>) 等<a href="Variables.htm#Operators">运算符</a>与其他条件结合在一起.</p>
<pre>if (Var1 &gt;= Low and Var1 &lt;= High)
if Var1 between %Low% and %High%  
</pre>

<h3 id="different-equals">不同的等号</h3>
<p>一个常见的错误是在需要 <code>:=</code> 的地方写 <code>=</code>. 例如:</p>
<pre>Total = A + B   <em>; 赋值原义文字 "A + B"</em>
</pre>
<p>这可能很难避免(至少在删除传统赋值语法之前), 但是赋值时总是使用 <code>:=</code> 会有所帮助.</p>
<p>等号(当不用另一个符号, 如 <code>&lt;=</code>) 具有以下含义:</p>
<ul>
  <li><a href="commands/SetEnv.htm">传统赋值</a>: <code>Var = Value</code></li>
  <li><a href="commands/IfEqual.htm">传统的 If 相等</a>: <code>if Var = Value</code></li>
  <li><a href="Variables.htm#equal">不区分大小写的相等</a>: <code>if (Expr1 = Expr2)</code> (在其他表达式中也有效, 不只是 <code>if</code>)</li>
  <li><a href="Variables.htm#comma">在逗号后的赋值</a>: <code>x:=1, y=2, a=b=c</code> (所有的都是赋值, 由于一个特殊的规则)</li>
  <li><a href="Functions.htm#DeclareInit">声明和初始化</a>: <code>local x = Expr</code> (总是接受一个表达式)</li>
  <li><a href="Functions.htm#optional">设置参数的默认值</a>: <code>MyFunc(Param="Default value") {</code>...</li>
</ul>
<p>前两种情况可以通过始终使用 <code>:=</code> <a href="Variables.htm#AssignOp">赋值运算符</a>和 <a href="commands/IfExpression.htm">if (表达式)</a> 来避免.</p>
<p>对于最后三种情况, <code>:=</code> 应该用来代替 <code>=</code>.</p>

<h3 id="commands-vs-functions">命令与函数</h3>
<p>在 AutoHotkey v1 中, 目前无法在表达式中调用命令, 或者使用 <em>命令语法</em> 调用函数. 但是, 这几个命令有函数替换.</p>
<table class="info">
  <tr><th>命令</th><th>替换</th></tr>
  <tr><td><a href="commands/FileAppend.htm">FileAppend</a></td><td><a href="commands/FileOpen.htm">FileOpen</a> 和 <a href="objects/File.htm#Write">File.Write</a></td></tr>
  <tr><td><a href="commands/FileGetAttrib.htm">FileGetAttrib</a></td><td><a href="commands/FileExist.htm">FileExist</a></td></tr>
  <tr><td><a href="commands/FileRead.htm">FileRead</a></td><td><a href="commands/FileOpen.htm">FileOpen</a> 和 <a href="objects/File.htm#Read">File.Read</a></td></tr>
  <tr><td><a href="commands/GetKeyState.htm#command">GetKeyState</a></td><td><a href="commands/GetKeyState.htm#function">GetKeyState</a> (函数返回 0 或 1, 不是 "U" 或 "D")</td></tr>
  <tr><td><a href="commands/IfExist.htm">IfExist</a></td><td><a href="commands/FileExist.htm">FileExist</a></td></tr>
  <tr><td><a href="commands/IfInString.htm">IfInString</a></td><td><a href="commands/InStr.htm">InStr</a></td></tr>
  <tr><td><a href="commands/IfWinActive.htm">IfWinActive</a></td><td><a href="commands/WinActive.htm">WinActive</a></td></tr>
  <tr><td><a href="commands/IfWinExist.htm">IfWinExist</a></td><td><a href="commands/WinExist.htm">WinExist</a></td></tr>
  <tr><td><a href="commands/StringGetPos.htm">StringGetPos</a></td><td><a href="commands/InStr.htm">InStr</a></td></tr>
  <tr><td><a href="commands/StringLen.htm">StringLen</a></td><td><a href="commands/StrLen.htm">StrLen</a></td></tr>
  <tr><td><a href="commands/StringReplace.htm">StringReplace</a></td><td><a href="commands/StrReplace.htm">StrReplace</a></td></tr>
  <tr><td><a href="commands/StringSplit.htm">StringSplit</a></td><td><a href="commands/StrSplit.htm">StrSplit</a></td></tr>
  <tr>
    <td><a href="commands/StringLower.htm">StringLower<br>StringUpper</a></td>
    <td><code><a href="commands/Format.htm">Format</a>("{:L}", input)</code>, <code>Format("{:U}", input)</code> 或 <code>Format("{:T}", input)</code></td>
  </tr>
  <tr>
    <td><a href="commands/StringLeft.htm">StringLeft</a><br><a href="commands/StringMid.htm">StringMid</a><br><a href="commands/StringLeft.htm">StringRight</a><br><a href="commands/StringTrimLeft.htm">StringTrimLeft</a><br><a href="commands/StringTrimLeft.htm">StringTrimRight</a></td>
    <td><a href="commands/SubStr.htm">SubStr</a></td>
  </tr>
</table>

<h2 id="control-flow">控制流语句</h2>
<p class="note">有关控制流的一般说明, 请参阅<a href="Concepts.htm#control-flow">控制流</a>.</p>
<p><a href="Concepts.htm#statement">语句</a>通过将他们括在大括号 <code>{}</code> 中(如 C, JavaScript 和类似语言) 组合成<a href="commands/Block.htm"><em>块</em></a>, 但通常, 大括号必须出现在行的开头. 控制流语句可以应用于整个块或者只是一个语句.</p>
<p>控制流程语句的<a href="Concepts.htm#cf-body">主体</a>总是 <em>一组</em> 语句. 块被视为一组语句, 就像控制流语句及其主体一样. 以下相关语句与其主体一起彼此分组: <code>If</code> 和 <code>Else</code>; <code>Loop</code>/<code>For</code> 和 <code>Until</code>; <code>Try</code> 和 <code>Catch</code> 和/或 <code>Finally</code>. 换句话说, 当这些语句组作为一个整体使用时, 并不总是需要用大括号括起来(但是, 为了清楚起见, 一些编码样式总是包含大括号).</p>
<p>控制流语句, 它具有一个主体, 因此必须总是跟着一个相关的语句或一组语句: <code>If</code>, <code>Else</code>, <code>Loop</code>, <code>While</code>, <code>For</code>, <code>Try</code>, <code>Catch</code> 和 <code>Finally</code>.</p>
<p id="control-flow-list">下面的控制流语句如下:</p>
<ul>
  <li>一个<a href="commands/Block.htm">块</a>(用一对大括号表示) 将零个或多个语句组合为一个语句.</li>
  <li>一个 <a href="#if-statement">If 语句</a>导致其主体被执行或不依赖条件. 其后可以跟一个 <a href="commands/Else.htm">Else</a> 语句, 只有当条件不满足时才执行.</li>
  <li><a href="commands/Goto.htm">Goto</a> 跳转到指定的标签并继续执行.</li>
  <li><a href="commands/Gosub.htm">Gosub</a> 调用一个<a href="#subroutines">子程序</a>.</li>
  <li><a href="commands/Return.htm">Return</a> 从一个<a href="#subroutines">子程序</a>或函数返回.</li>
  <li>一个 <a href="#loop-statement">Loop(循环) 语句</a> (<a href="commands/Loop.htm">Loop</a>, <a href="commands/While.htm">While</a> 或 <a href="commands/For.htm">For</a>) 重复执行其主体.
  <ul>
    <li><a href="commands/Break.htm">Break</a> 退出(终止) 一个循环.</li>
    <li><a href="commands/Continue.htm">Continue</a> 跳过当前循环迭代的其余部分, 并开始一个新的循环.</li>
    <li><a href="commands/Until.htm">Until</a> 直到表达式计算结果为 true 时, 循环终止. 表达式在每次迭代之后被计算.</li>
  </ul></li>
  <li><a href="commands/Switch.htm">Switch</a> 从互斥候选项列表中执行其中一个实例.</li>
  <li>异常处理:
  <ul>
    <li><a href="commands/Try.htm">Try</a> 保护它的主体不受运行错误和 throw 命令抛出的异常的影响.</li>
    <li><a href="commands/Catch.htm">Catch</a> 在 try 语句中抛出异常后执行它的主体(仅当在抛出异常的情况下).</li>
    <li><a href="commands/Finally.htm">Finally</a> 在当控制权从 try 或 catch 语句的主体转出时, 执行其主体.</li>
    <li><a href="commands/Throw.htm">Throw</a> 抛出一个异常, 通过 try/catch 或显示错误对话框来处理.</li>
  </ul></li>
</ul>

<h3 id="control-flow-vs-commands">控制流与命令</h3>
<p>控制流语句具有类似于<a href="#commands">命令</a>的语法, 并且经常被引用为这样, 但也有不同于命令的地方:</p>
<ul>
  <li><a href="#if-statement">If 语句</a>有几种类型, 每种都有不同的语法.</li>
  <li><a href="commands/For.htm">For</a> 几种类型的 <a href="#if-statement">If 语句</a>使用关键字或运算符而不是逗号来分隔它们的一些参数.</li>
  <li><a href="commands/Block.htm">块</a>的左大括号可以写在 <a href="commands/IfExpression.htm">If (expression)</a>, <a href="commands/Else.htm">Else</a>, <a href="commands/Loop.htm">Loop Count</a>, <a href="commands/While.htm">While</a>, <a href="commands/For.htm">For</a>, <a href="commands/Try.htm">Try</a>, <a href="commands/Catch.htm">Catch</a> 或 <a href="commands/Finally.htm">Finally</a> 语句的同一行的末尾(基本上任何不使用<a href="#legacy-syntax">传统语法</a>的控制流语句). 这被称为 One True Brace(OTB) 风格. 它不受其他 Loop 子命令或<a href="#legacy-if">传统 If 语句</a>的支持, 因为大括号将被解释为原义文本 <code>{</code> 字符.</li>
  <li><a href="commands/Else.htm">Else</a>, <a href="commands/Try.htm">Try</a> 和 <a href="commands/Finally.htm">Finally</a> 允许任何有效的语句在其右侧, 因为它们需要一个<a href="Concepts.htm#cf-body">主体</a>但没有参数.</li>
  <li><a href="commands/IfExpression.htm">If (表达式)</a> 和 <a href="commands/While.htm">While</a> 允许在名称后立即使用左括号. 例如, <code>if(表达式)</code>.</li>
  <li><a href="commands/For.htm">For</a>, <a href="commands/While.htm">While</a>, <a href="commands/Until.htm">Until</a> 和 <a href="commands/Throw.htm">Throw</a> 总是接受表达式. 他们将 <code>%var%</code>, <code>%var%000</code> 和类似的视为表达式, 而其他命令的<a href="#numeric-parameters">数字参数</a>则不会. 向后兼容性的要求不适用于这些控制流语句, 因为它们相对较新.</li>
</ul>

<h3 id="if-statement">If 语句</h3>
<p><a href="commands/IfExpression.htm">If (表达式)</a> 计算表达式并仅在结果为真时执行以下语句.</p>
<p id="legacy-if"><strong>混淆的常见原因:</strong> 有几种其他类型的 If 语句, 其中一些看起来非常类似 <em>If (表达式)</em>. 在新的脚本中应该避免这些. 如果有疑问, 最好总是以左括号作为表达式的开始. "传统" If 语句如下所示:</p>
<ul>
  <li><a href="commands/IfEqual.htm">If Var <em>op</em> Value</a>, <em>op</em> 是以下运算符之一: <code>=</code>, <code>&lt;&gt;</code>, <code>!=</code>, <code>&gt;</code>, <code>&gt;=</code>, <code>&lt;</code>, <code>&lt;=</code>.</li>
  <li><a href="commands/IfBetween.htm">If Var [not] between Lower and Upper</a></li>
  <li><a href="commands/IfIn.htm">If Var [not] in/contains MatchList</a></li>
  <li><a href="commands/IfIs.htm">If Var is [not] Type</a></li>
</ul>
<p>任何不符合上述用法之一的 If 语句被解释为 <a href="commands/IfExpression.htm">If (表达式)</a>.</p>
<p>这些是与传统的 If 语句相关的一些常见的混淆点:</p>
<ul>
  <li>变量名称 <em>只有</em> 在运算符的右侧时才必须用百分号括起来.</li>
  <li><code>between</code>, <code>in</code>, <code>contains</code> 和 <code>is</code> 只在上下文中是有效的; 他们不能用在<a href="#expressions">表达式</a>中.</li>
  <li>多个条件不能写在同一行上(如使用 <code>and</code> 运算符).</li>
  <li>没有任何参数是表达式.</li>
</ul>
<p id="named-if">If 语句同样有以下的 "传统" 名称:</p>
<ul>
  <li><a href="commands/IfEqual.htm">IfEqual, IfNotEqual, IfLess, IfLessOrEqual, IfGreater 和 IfGreaterOrEqual</a></li>
  <li><a href="commands/IfExist.htm">If[Not]Exist</a></li>
  <li><a href="commands/IfInString.htm">If[Not]InString</a></li>
  <li><a href="commands/IfWinActive.htm">If[Not]WinActive</a></li>
  <li><a href="commands/IfWinExist.htm">If[Not]WinExist</a></li>
  <li><a href="commands/IfMsgBox.htm">IfMsgBox</a></li>
</ul>
<p>除了 IfMsgBox, 这些都是过时的, 一般应该避免用在新的脚本中.</p>
<p>命名的 If 语句允许与<a href="#commands">命令</a>写在同一行, 但是拼写错误的命令名称被视为文字文本. 这样的错误可能难以检测到.</p>

<h3 id="loop-statement">Loop 语句</h3>
<p>有几种类型的 Loop(循环) 语句:</p>
<ul>
  <li><a href="commands/Loop.htm">Loop Count</a> 重复执行一个语句: 可以指定表示重复次数的数字(Count) 或直到遇到 <a href="Break.htm">break</a>.</li>
  <li><a href="commands/LoopReg.htm">Loop Reg</a> 获取指定的注册表子键的内容, 每次一个项目.</li>
  <li><a href="commands/LoopFile.htm">Loop Files</a> 获取指定的文件或文件夹, 每次一个.</li>
  <li><a href="commands/LoopParse.htm">Loop Parse</a> 从一个字符串中获取子字符串(片段), 每次一个.</li>
  <li><a href="commands/LoopReadFile.htm">Loop Read</a> 获取文本文件中的行, 每次一行.</li>
  <li><a href="commands/While.htm">While</a> 重复执行一个语句, 一直到指定的<a href="../Variables.htm#Expressions">表达式</a>计算结果为假. 每次迭代(重复) 前计算表达式的结果.</li>
  <li><a href="commands/For.htm">For</a> 对每一个值或枚举器返回的每对键值对执行一个语句, 如对象中的每对键值对.</li>
</ul>
<p><a href="commands/Break.htm">Break</a> 退出(终止) 一个循环, 有效地跳到循环主体后面的下一行.</p>
<p><a href="commands/Continue.htm">Continue</a> 跳过当前循环迭代的其余部分, 并开始一个新的循环.</p>
<p><a href="commands/Until.htm">Until</a> 表达式计算结果为 true 时, 循环终止. 表达式在每次迭代之后被重新计算.</p>
<p><a href="#labels">标签</a>可以用来 "命名" <a href="commands/Continue.htm">Continue</a> 和 <a href="commands/Break.htm">Break</a> 的循环. 这允许脚本轻松地继续或跳出任何数量的嵌套循环而不使用 <a href="commands/Goto.htm">Goto</a>.</p>
<p>内置变量 <strong>A_Index</strong> 包含当前循环迭代的编号. 它在第一次执行循环主体时为 1. 第二次时为 2; 依次类推. 如果一个内部循环被外部循环包围, 则内部循环优先. A_Index 适用于所有类型的循环, 但在循环之外为 0.</p>
<p>对于某些循环类型, 其他内置变量返回有关当前循环项 (注册表 键/值, 文件, 子字符串或文本行) 的信息. 这些变量的名称以 <strong>A_Loop</strong> 开头, 如 A_LoopFileName 和 A_LoopReadLine. 它们的值总是对应于最近开始的(但还没有停止) 循环的适应类型. 例如, A_LoopField 返回最里层解析循环中的当前子字符串, 即使它在文件或注册表循环中使用.</p>
<pre>t := "column 1`tcolumn 2`nvalue 1`tvalue 2"
Loop Parse, t, `n
{
    rowtext := A_LoopField
    rownum := A_Index  <em>; 保存这个用于下面的第二个循环中.</em>
    Loop Parse, rowtext, `t
    {
        MsgBox %rownum%:%A_Index% = %A_LoopField%
    }
}
</pre>
<p>循环变量也可以在循环体外部使用, 例如在循环中调用的函数或子程序中.</p>

<h3 id="not-control-flow">非控制流</h3>
<p>像指令, 标签(包括热键和热字串) 和没有赋值的声明在脚本从文件加载的时候被处理, 它们不受控制流的制约. 换句话说, 在脚本执行任何控制流程语句之前, 它们将无条件生效. 同样, #If 指令如 <a href="commands/_If.htm">#IfWinActive</a> 不能影响控制流; 他们只是设置代码中指定的任何热键标签和热字串的标准. 每次按下时都会计算热键的条件, 而不是在代码中遇到 #If 指令时.</p>

<h2 id="structure-of-a-script">脚本的结构</h2>

<h3 id="auto-execute-section">自动执行段</h3>
<p>脚本加载完成后, 从顶行开始执行, 直到遇到 <a href="commands/Return.htm">Return</a>, <a href="commands/ExitApp.htm">Exit</a>, 脚本的第一个<a href="Hotkeys.htm">热键/热字串标签</a>, 或脚本的物理结束(无论哪一种). 这个脚本的顶部被称为 <em>自动执行段(部分)</em>, 但它实际上只是程序启动后调用的一个<a href="#subroutines">子程序</a>.</p>
<p class="warning"><strong>注意:</strong> 虽然脚本的 <em>第一个</em> 热键/热字串标签有与 <a href="commands/Return.htm">return</a> 相同的效果, 但是其他热键和标签不会.</p>
<p>自动执行段通常用于配置适用于每个新启动的<a href="misc/Threads.htm">线程</a>的设置. 有关详细信息, 请参阅<a href="Scripts.htm#auto">脚本的顶部</a>.</p>

<h3 id="subroutines">子程序</h3>
<p><em>子程序</em> 是一个可重复使用的代码块, 可以 <em>调用</em> 它来执行一些任务.</p>
<p>脚本使用子程序来定义当按下特定热键或发生其他事件时应该发生什么. 脚本也可以通过使用 <a href="commands/Gosub.htm">Gosub</a> 直接调用子程序.</p>
<p>任何<a href="#labels">标签</a>都可以作为子程序的起点. 一个子程序没有明确的标记结束点, 而是通过 <a href="commands/Return.htm">Return</a> 或当线程退出时, 控制权返回到子程序的调用者时作为结束. 例如:</p>
<pre>gosub Label1  <em>; 代码运行时, 第一个对话框内容为 "Label1".</em>

Label1:
MsgBox %A_ThisLabel%  <em>; 第二个对话框内容为空.</em>
return
</pre>
<p>请注意: 当正常运行时, 标签无效, 在上个例子中对话框将显示两次: 一次在子程序运行时, 一次在它返回之后. 一个重要的结果是不能在另一个子程序中定义一个子程序
, 因为内部子程序的 "主体" 会自动执行然后 <em>return</em>, 从而有效地终止外部子程序.</p>
<p>子程序通常应该单独定义到任何其他代码块, 但也可以在<a href="Functions.htm#gosub">函数内定义</a>, 允许子程序访问该函数的静态变量(和局部变量, 但仅在函数运行时).</p>
<p class="warning"><strong>注意:</strong> 函数内定义的子程序在使用局部变量和<a href="#dynamic-variables">动态变量引用</a>, 包括 <a href="commands/Gui.htm#Events">Gui 控件变量</a>方面有一定的限制. 有关详细信息, 请参阅<a href="Functions.htm#gosub">在函数中使用子程序</a>.
</p>

<h3 id="user-defined-functions">用户自定义函数</h3>
<p>一般来说, <a href="Functions.htm">函数</a>是一种子程序. 但是, 在 AutoHotkey 文档中, "子程序" 通常指的是由标签定义的子程序类型(如上所述).</p>
<p>用户定义的函数与子程序的不同之处在于它们可以 <em>接受参数</em> 并 <em>返回一个值</em>, 并且它们可以具有<a href="Functions.htm#Local">局部变量</a>. 它们可以通过脚本中的<a href="#function-calls">函数调用</a>或程序本身调用, 例如, 如果函数被传递给 <a href="commands/Hotkey.htm">Hotkey</a> 或 <a href="commands/SetTimer.htm">SetTimer</a> 命令.</p>
<p>函数是使用类似于函数调用的语法来定义的, 随后是用大括号括起来的代码块:</p>
<pre>MyFunction(FirstParameter, Second, ByRef Third, Fourth:="")
{
    ...
    return "a value"
}
</pre>
<p>和函数调用一样, 函数名和左括号之间不能有空格.</p>
<p>右括号和左大括号之间的换行符是可选的. 两者之间可以有任意数量的空格或注释.</p>
<p><a href="Functions.htm#ByRef">ByRef</a> 表示该参数接受变量引用, 使该参数成为调用者传递的变量的别名. 如果调用者没有传递一个变量, 那么这个参数就像一个普通的局部变量. ByRef 参数也可以是可选的.</p>
<p><a href="Functions.htm#optional">可选</a>参数通过在参数名称后面指定 <code>:=</code> 或 <code>=</code> 和一个默认值, 该值必须是加引号的原义字符串, 数字, <code>true</code> 或 <code>false</code>. 由于历史原因, 运算符 <code>:=</code> 和 <code>=</code> 可以互换, 但最好使用 <code>:=</code> 以与表达式中的赋值保持一致.</p>
<p>函数可以<a href="Functions.htm#return">返回一个值</a>. 如果不是, 则默认返回一个空字符串.</p>
<p>一个函数不能在另一个函数中定义. 另外, 函数定义的位置并不重要; 在脚本中定义的任何函数都可以从其他地方调用.</p>
<p class="note">请参阅<a href="Functions.htm">函数</a>以了解更多详细信息.</p>

<h3 id="-include">#Include</h3>
<p><a href="commands/_Include.htm">#Include</a> 指令使脚本的行为就像指定文件的内容出现在这个确切位置一样. 这通常用于将代码组织到单独的文件中, 或者使用其他用户编写的脚本库.</p>
<p class="warning"><strong>注意:</strong> 以下段落详细说明了一些常见的混淆点.
</p>
<p>使用 #Include 时, 重要的是要考虑文件的内容如果放置在该位置将会产生什么效果, 因为 #Include 将具有相同的效果. 例如:</p>
<ul>
  <li>
<p>#Include 一般不应该在子程序或函数的中间使用.</p>
</li>
  <li>
<p>在脚本的<a href="#auto-execute-section">自动执行段</a>使用 #Include 需要特别的考虑, 因为自动执行段基本上只是一个子程序. 如果子程序的执行会在到达一个 <code>return</code> 时终止, 而不管 <code>return</code> 是在哪个文件中. 同样, 如果文件包含一个热键/热字串, 它可能被认为是脚本的 <em>第一个</em> 热键/热字串, 它将扮演 <code>return</code> 的角色.</p>
</li>
  <li>
<p>脚本只有一个<a href="#auto-execute-section">自动执行段</a>, 而不是每个文件一个.</p>
</li>
</ul>
<p>#Include 可以在<a href="#auto-execute-section">自动执行段</a>安全地使用, 以包含仅包含函数定义的文件, 因为函数定义(但不是函数调用) 在执行期间被跳过. 如果一个文件包含其他代码, 可以通过 <a href="commands/Goto.htm">Goto</a> 跳过文件的内容来避免破坏自动执行段.</p>
<p>与 C/C++ 不同, 如果以前的指令已包含该文件, #Include 不做任何事情. 要多次包含同一文件的内容, 请使用 <a href="commands/_Include.htm">#IncludeAgain</a>.</p>
<p>如果包含函数的脚本文件被保存在一个标准的位置并进行适当的命名, 则它们可以 <em>自动包含</em>, 而不必使用 #Include. 其效果与在主脚本文件末尾使用 #Include 相似. 有关详细信息, 请参阅<a href="Functions.htm#lib">函数库</a>.</p>

<h2 id="misc">杂项</h2>

<h3 id="dynamic-variables">动态变量</h3>
<p><em>动态变量引用</em> 采用文本值, 并将其解释为变量的名称.</p>
<p>动态变量引用的最常见形式称为 <em>双重引用</em> 或 <em>双重解引</em>. 在执行双重引用之前, 目标变量的名称存储在第二个变量中. 然后可以通过使用双重引用将第二个变量间接地将值赋给目标变量. 例如:</p>
<pre>target := 42       <em>; target(目标) := 42</em>
second := "target" <em>; second(第二个变量) := "target(目标)"</em>
MsgBox   %second%  <em>; 文本中的普通(单一) 变量引用 =&gt; target(目标)</em>
MsgBox %  second   <em>; 表达式中的普通(单一) 变量引用 =&gt; target(目标)</em>
MsgBox % %second%  <em>; 表达式中的双重引用 =&gt; 42</em>
</pre>
<p>首先, 看起来百分号有不同的含义, 取决于它们是在文本中还是在表达式中使用. 然而, 在这 <em>两种</em> 情况下, 将 <code>%second%</code> 换为变量 <code>second</code> 的内容可能更有意义:</p>
<ul>
  <li><code>MsgBox %second%</code> &rarr; <code>MsgBox target</code>: 显示 "target".</li>
  <li><code>MsgBox % %second%</code> &rarr; <code>MsgBox % target</code>: 显示 <code>target</code> 的内容, 如 "42".</li>
</ul>
<p>目前, 第二种情况下, <code>second</code> 必须总是包含一个变量名; 任意表达式不被支持.</p>
<p>动态变量引用也可以采用一个或多个文本文本和一个或多个变量的内容, 并将它们组合在一起组成一个单一变量名. 在没有空格的情况下, 这只需简单地按顺序写入名称和百分号括起来的变量. 例如, <code>MyArray%A_Index%</code> 或 <code>MyGrid%X%_%Y%</code>. 这用于访问 <em>伪数组</em>, 如下所示.</p>
<p>有关如何解析函数内的动态变量引用的说明, 请参阅<a href="Functions.htm#Dynamic">函数: 关于局部和全局变量的更多信息</a>.</p>

<h4 id="pseudo-arrays">伪数组</h4>
<p><em>伪数组</em> 实际上只是一堆分开的变量, 但是有一个命名模式, 可以像数组元素一样使用它. 例如:</p>
<pre>MyArray1 = A
MyArray2 = B
MyArray3 = C
Loop 3
    MsgBox % MyArray%A_Index%  <em>; 显示 A, 然后 B, 最后 C.</em>
</pre>
<p>由于单个元素只是普通变量, 所以可以赋值或获取一个值, 但不能 <em>删除</em> 或 <em>插入</em> 元素. 因为伪数组本身并不存在, 所以不能将它传递给函数或从函数返回, 或者作为一个整体进行复制. 由于这些原因, 通常建议在可能的情况下使用<a href="Objects.htm#Usage_Simple_Arrays">普通数组</a>.</p>

<h4 id="associative-pseudo-arrays">关联伪数组</h4>
<p>用于形成最终变量名称的 "index(索引)" 不一定是数字; 它可以是一个字母或关键字, 使伪数组类似于<a href="Objects.htm#Usage_Associative_Arrays">关联数组</a>或<a href="Objects.htm">对象</a>. 下面的例子创建一个元素为 "Left", "Top", "Right" 和 "Bottom" 的伪数组:</p>
<pre>SysGet, WA, MonitorWorkArea
MsgBox, Left: %WALeft% -- Top: %WATop% -- Right: %WARight% -- Bottom: %WABottom%.
</pre>

<h4 id="commands-which-create-pseudo-arrays">创建伪数组的命令</h4>
<p>有几个命令可以创建关联的伪数组:</p>
<ul>
  <li><a href="commands/GuiControlGet.htm">GuiControlGet Pos</a>.</li>
  <li><a href="commands/RegExMatch.htm">RegExMatch</a>, 除非指定了 <code>O)</code> 选项, 这会导致它输出包含所有匹配信息的单个对象.</li>
  <li><a href="commands/SysGet.htm">SysGet Monitor/MonitorWorkArea</a>, 如上所示.</li>
  <li><a href="commands/StringSplit.htm">StringSplit</a>. 新的脚本应该使用 <a href="commands/StrSplit.htm">StrSplit()</a> 作为代替, 因为它创建的是<a href="Objects.htm#Usage_Simple_Arrays">普通数组</a>.</li>
  <li><a href="commands/WinGet.htm">WinGet List</a>.</li>
</ul>
<p class="warning"><strong>警告:</strong> 这些命令不遵循与 <em>动态变量引用</em> 相同的规则. 如果在一个函数中使用, 则所得到的伪数组或者全部是全局的或者全部是局部的, 这仅取决于数组的第一个元素(或基于名称). 如果没有单独声明, 伪数组中的一些变量可能是不可访问的. 有关详细信息, 请参阅<a href="Functions.htm#PseudoArrays">函数: 关于局部变量和全局变量的更多信息</a>.
</p>
<p>AutoHotkey 还创建了一个全局伪数组, 以包含传递给脚本的所有<a href="Scripts.htm#cmd_args">命令行参数</a>.</p>

<h3 id="labels">标签</h3>
<p>标签标识只是一行代码, 可以用作 <a href="commands/Goto.htm">Goto</a> 目标或形成<a href="#subroutines">子程序</a>. 有三种标签: 普通标签, <a href="Hotkeys.htm">热键</a>标签和<a href="Hotstrings.htm">热字串</a>标签.</p>
<p>普通标签由一个名称后跟一个冒号组成.</p>
<pre>this_is_a_label:
</pre>
<p>热键标签由一个热键后跟双冒号组成.</p>
<pre>^a::
</pre>
<p>热字串标签由一个冒号, 零个或多个<a href="Hotstrings.htm#Options">选项</a>, 另一个冒号, 缩写字符和双冒号组成.</p>
<pre>:*:btw::
</pre>
<p>通常, 除了空格和注释之外, 其他代码不能与标签一起写在同一行上. 然而:</p>
<ul>
  <li>一个热键标签可以直接跟随一个命令或其他语句来创建 <em>单行</em> 热键. 换句话说, 如果一个命令, 赋值或表达式与热键标签位于同一行上, 它的行为就好像跟着 <code>return</code> 一样.</li>
  <li>热键和写在双冒号右边的<a href="KeyList.htm">键名</a>实际上是<a href="misc/Remap.htm"><em>重映射</em></a>, 这是<a href="misc/Remap.htm#actually">热键对</a>的快速写法. 例如, <code>a::b</code> 创建热键和标签 <code>*a</code> 和 <code>*a Up</code>, 并不创建名为 <code>a</code> 的标签.</li>
  <li>热字串和写在最后的双冒号的右边的文本是一个 <em>自动替换</em> 热字串. 自动替换热字串不作为标签.</li>
</ul>
<p>有关详细信息, 请参阅<a href="misc/Labels.htm">标签</a>.</p>

</body>
</html>